On CI this fails in __setitem__, in the ndarrays_to_tensors logic, when doing tensor[slice] = list:

self = <test_numeric.TestBoolCmp object at 0x7f5910f1f460>

    def setup_method(self):
        self.f = np.ones(256, dtype=np.float32)
        self.ef = np.ones(self.f.size, dtype=bool)
        self.d = np.ones(128, dtype=np.float64)
        self.ed = np.ones(self.d.size, dtype=bool)
        # generate values for all permutation of 256bit simd vectors
        s = 0
        for i in range(32):
>           self.f[s:s+8] = [i & 2**x for x in range(8)]

torch_np/tests/numpy_tests/core/test_numeric.py:464: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = array_w([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
        1., 1., 1., 1., 1., 1., 1., 1...., 1., 1., 1.,
        1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
        1., 1., 1., 1.])
index = slice(0, 8, None), value = (0, 0, 0, 0, 0, 0, ...)

    def __setitem__(self, index, value):
        index = _helpers.ndarrays_to_tensors(index)
        index = ndarray._upcast_int_indices(index)
        value = _helpers.ndarrays_to_tensors(value)
>       return self._tensor.__setitem__(index, value)
E       TypeError: can't assign a tuple to a torch.FloatTensor

Any suggestions @honno?

To me it looks like we need to wrap sequences as tensors as an additional step, as its saying tensors can't handle an input NumPy can

In [1]: t = torch.zeros(256)
[PYFLYBY] import torch

In [2]: t[0:8] = [0. for _ in range(8)]
TypeError: can't assign a list to a torch.FloatTensor

In [3]: x = np.zeros(256)
[PYFLYBY] import numpy as np

In [4]: x[0:8] = [0. for _ in range(8)]

I think this is a regression I caused by replacing asarray(value).get() with _helpers.ndarrays_to_tensors(value), but we shouldn't revert that (we want to handled nested sequences which contain tnp.ndarray elements), so maybe instead asarray() selectively on flat sequence objects...

>>> t[0:8] = torch.as_tensor([0. for _ in range(8)])
# no errors

so maybe instead asarray() selectively on flat sequence objects...

Something like

from typing import Sequence
...
   def __setitem__(...):
        ...
        if isinstance(value, Sequence) and all(
            isinstance(e, (int, float, complex)) for e in value
        ):
            value = asarray(value).get()
        ...

Doesn't cover nested sequence setting (I'd want to introduce a new thorough test for that—feel free to assign), but this change is easy and supports by-far the most common sequenced-value setting operation.

How does NumPy process these nested sequences into an array? It may be best to simply copy their algorithm.

What numpy actually does is well hidden in its C code. Maybe this test is of help: https://github.com/numpy/numpy/blob/main/numpy/core/tests/test_indexing.py#L808

My point is, this logic must be somewhere, in Python, C, or whichever language. We may be able to carve it out and implement it here in Python. That's what we did for plenty of functions in PrimTorch really.
Sometimes this is more difficult than abstracting out the ideas and implementing those, but what we found was that this is often more precise than trying to abstract things out.

OK, this PR has run its course. ndarray.view is in main, fancy indexing is TODO, best tackled in one go not piecemeal.